package algorithm.niuke;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 数组问题
 *
 * @author jack.wu
 * @version 1.0
 * @date 2020-05-12
 */
public class ArrayTest {

    public static void main(String[] args) {
        int[] array = {1, 4, 7, 8, 3, 5, 40, 11};
        reOrderArray(array);
        System.out.println(Arrays.toString(array));

        int[][] matrix = {{1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
                {13, 14, 15, 16}};

        ArrayList<Integer> result = printMatrix(matrix);
        System.out.println(result);


    }

    /**
     * 奇数在前，偶数在后
     * 思路：根据冒泡排序思想，如果前面这个数是偶数，紧接着后面这个数是奇数，直接交换
     *
     * @param array 目标数组
     */
    private static void reOrderArray(int[] array) {

        for (int i = 0; i < array.length - 1; i++) {
            int temp;
            for (int j = 0; j < array.length - i - 1; j++) {
                if ((array[j] % 2 == 0) && (array[j + 1] % 2 != 0)) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

    }

    /**
     * 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字
     *
     * @param matrix 矩阵
     * @return 顺时针打印集合
     */
    private static ArrayList<Integer> printMatrix(int[][] matrix) {

        // 定义结果集
        ArrayList<Integer> result = new ArrayList<>(16);

        if (matrix == null) {
            return result;
        }

        // 定义开始的四个顶点
        int left = 0, top = 0, right = matrix[0].length - 1, bottom = matrix.length - 1;

        // 开始处理
        while (left <= right && top <= bottom) {
            // 从左向右
            for (int i = left; i <= right; i++) {
                result.add(matrix[top][i]);
            }
            // 从上到下
            for (int j = top + 1; j <= bottom; j++) {
                result.add(matrix[j][right]);
            }
            // 从右向左
            if (top != bottom) {
                // 不只一行
                for (int k = right - 1; k >= left; k--) {
                    result.add(matrix[bottom][k]);
                }
            }
            // 从下到上
            if (left != right) {
                // 不只一列
                for (int n = bottom - 1; n > top; n--) {
                    result.add(matrix[n][left]);
                }
            }

            // 下一轮
            left++;
            right--;
            top++;
            bottom--;
        }

        return result;

    }


    /**
     * 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字
     *
     * @param array 数组
     * @return 次数超过数组长度的一半的数字
     */
    private int moreThanHalfNumo(int[] array) {
        if (array == null || array.length == 0) {
            return 0;
        }

        int count = 0;
        int length = array.length;
        Arrays.sort(array);

        // 如果有这个数，那么中间这个数就是要找的数
        int num = array[length / 2];

        // 统计出现的次数
        for (int value : array) {
            if (num == value) {
                count++;
            }
        }
        // 如果出现的次数小于数组长度的一半 还是不满足
        if (count <= (length / 2)) {
            return 0;
        }
        return num;

    }

}
